// 请求处理模块

import { log, displayResult } from './logger.js';

/**
 * 初始化请求处理模块
 */
export function initRequestHandlers() {
    setupRequestButtonHandlers();
}

/**
 * 设置请求按钮事件处理
 */
export function setupRequestButtonHandlers() {
    // 发送请求按钮
    window.appDOM.sendRequestBtn.addEventListener('click', sendCustomRequest);

    // 快速操作按钮
    window.appDOM.quickActionButtons.forEach(button => {
        button.addEventListener('click', handleQuickAction);
    });
}

/**
 * 发送自定义请求
 */
export async function sendCustomRequest() {
    try {
        const { requestMethodSelect, requestParamsInput } = window.appDOM;

        if (!window.appState.connected) {
            log('请先连接服务器', 'error');
            return;
        }

        const method = requestMethodSelect.value;
        let params = null;

        // 先解析参数
        if (requestParamsInput.value.trim()) {
            try {
                params = JSON.parse(requestParamsInput.value);
            } catch (e) {
                log(`参数解析错误: ${e.message}`, 'error');
                return;
            }
        }

        // 特殊处理特定的Client API请求，确保使用与快速操作相同的逻辑
        if (method === 'ping') {
            log('发送ping请求（不传递参数）', 'info');
            // 直接调用handlePing函数，与快速操作按钮使用相同的逻辑
            await handlePing();
            return;
        } else if (method === 'getServerInfo') {
            log('发送获取服务器信息请求', 'info');
            // 直接调用handleGetServerInfo函数
            await handleGetServerInfo();
            return;
        } else if (method === 'getCapabilities') {
            log('发送获取服务器能力请求', 'info');
            // 直接调用handleGetCapabilities函数
            await handleGetCapabilities();
            return;
        } else if (method === 'listTools' || method === 'tools/list') {
            log('发送列出工具请求', 'info');
            // 直接调用handleListTools函数
            await handleListTools();
            return;
        } else if (method === 'complete' || method === 'completion/complete') {
            log('发送补全请求', 'info');
            // 直接调用handleComplete函数
            await handleComplete();
            return;
        } else if (method === 'tools/call') {
            log('发送工具调用请求', 'info');
            // 直接调用handleCallTool函数
            await handleCallTool(params);
            return;
        }

        log(`发送请求: ${method} ${params ? JSON.stringify(params) : '无参数'}`, 'info');

        // 如果client对象不可用或没有request方法，直接使用transport发送请求
        await sendRequestWithTransport(method, params);

    } catch (error) {
        log(`发送请求过程中发生错误: ${error.message}`, 'error');
    }
}

/**
 * 使用transport对象发送请求
 * @param {string} method - 请求方法
 * @param {Object} params - 请求参数
 */
export async function sendRequestWithTransport(method, params) {
    try {
        if (!window.appState.transport || typeof window.appState.transport.send !== 'function') {
            throw new Error('transport对象不可用或不支持send方法');
        }

        log('降级到直接使用transport对象发送请求', 'info');

        let dataToSend;

        // 构建请求对象
        const requestObject = {
            jsonrpc: "2.0",
            id: "req-"+new Date().getTime(),
            method: method,
            params: params
        };

        log(`发送请求数据: ${JSON.stringify(requestObject)}`, 'debug');

        // 对于SSE连接，transport.send()需要字符串形式的数据
        // 序列化数据，确保与服务端反序列化兼容
        dataToSend = requestObject;

        const sendResult = window.appState.transport.send(dataToSend);

        // 检查send方法是否返回Promise
        if (sendResult && typeof sendResult.then === 'function') {
            try {
                const result = await sendResult;
                displayResult(result, false);
            } catch (e) {
                log(`transport请求失败: ${e.message}`, 'error');
            }
        } else {
            // 如果send方法不返回Promise，我们无法直接获取结果
            log('请求已发送，等待服务器响应（transport.send不返回Promise）', 'info');

            // 在这种情况下，我们需要依赖transport的onmessage事件来接收响应
            // 这里我们可以设置一个临时的监听器来获取特定请求的响应
            // 但为了简化，我们只记录请求已发送
        }

    } catch (error) {
        log(`使用transport发送请求失败: ${error.message}`, 'error');
    }
}

/**
 * 处理快速操作
 * @param {Event} event - 点击事件
 */
export async function handleQuickAction(event) {
    try {
        const action = event.currentTarget.dataset.action;

        if (!window.appState.connected) {
            log('请先连接服务器', 'error');
            return;
        }

        // Client API 操作按钮 - 填充到自定义请求中
        const clientApiActions = [
            'listTools', 'callTool', 'complete',
            'listResources', 'readResource',
            'subscribeResource', 'unsubscribeResource',
            'getSessionInfo', 'getClientInfo'
        ];

        if (clientApiActions.includes(action)) {
            log(`填充 ${action} 到自定义请求表单`, 'info');

            // 获取自定义请求表单元素
            const { requestMethodSelect, requestParamsInput } = window.appDOM;

            // 根据action设置请求方法和参数
            switch (action) {
                case 'listTools':
                    requestMethodSelect.value = 'tools/list';
                    requestParamsInput.value = '{}';
                    break;
                case 'callTool':
                    requestMethodSelect.value = 'tools/call';
                    requestParamsInput.value = JSON.stringify({
                        "name": "example_tool",
                        "arguments": {}
                    }, null, 2);
                    break;
                case 'complete':
                    requestMethodSelect.value = 'completion/complete';
                    requestParamsInput.value = JSON.stringify({
                        "text": "list"
                    }, null, 2);
                    break;
                case 'listResources':
                    requestMethodSelect.value = 'resources/list';
                    requestParamsInput.value = '{}';
                    break;
                case 'readResource':
                    requestMethodSelect.value = 'resources/read';
                    requestParamsInput.value = JSON.stringify({
                        "path": "example/path"
                    }, null, 2);
                    break;
                case 'subscribeResource':
                    requestMethodSelect.value = 'resources/subscribe';
                    requestParamsInput.value = JSON.stringify({
                        "path": "example/path"
                    }, null, 2);
                    break;
                case 'unsubscribeResource':
                    requestMethodSelect.value = 'resources/unsubscribe';
                    requestParamsInput.value = JSON.stringify({
                        "path": "example/path"
                    }, null, 2);
                    break;
                case 'getSessionInfo':
                    requestMethodSelect.value = 'getServerInfo';
                    requestParamsInput.value = '{}';
                    break;
                case 'getClientInfo':
                    requestMethodSelect.value = 'getServerInfo';
                    requestParamsInput.value = JSON.stringify({"client": true}, null, 2);
                    break;
            }

            // 滚动到自定义请求面板
            document.querySelector('.request-panel').scrollIntoView({
                behavior: 'smooth',
                block: 'start'
            });

            // 聚焦到请求参数输入框
            requestParamsInput.focus();
        } else {
            // 其他快速操作 - 直接执行
            log(`执行快速操作: ${action}`, 'info');

            switch (action) {
                case 'ping':
                    await handlePing();
                    break;
                case 'getServerInfo':
                    await handleGetServerInfo();
                    break;
                case 'getCapabilities':
                    await handleGetCapabilities();
                    break;
                default:
                    log(`未知的快速操作: ${action}`, 'error');
        }
        }
    } catch (error) {
        log(`执行快速操作过程中发生错误: ${error.message}`, 'error');
    }
}

/**
 * 处理ping请求
 */
async function handlePing() {
    try {
        // 尝试使用client的ping方法
        if (window.appState.client && typeof window.appState.client.ping === 'function') {
            try {
                const result = await window.appState.client.ping();
                displayResult(result, false);
            } catch (e) {
                log(`客户端ping请求失败: ${e.message}`, 'error');
                // 降级到发送自定义ping请求
                await sendRequestWithTransport('ping');
            }
        } else {
            // 降级到发送自定义ping请求
            await sendRequestWithTransport('ping');
        }
    } catch (error) {
        log(`ping过程中发生错误: ${error.message}`, 'error');
    }
}

/**
 * 处理获取服务器信息请求
 */
async function handleGetServerInfo() {
    try {
        // 尝试使用client的getServerVersion方法
        if (window.appState.client && typeof window.appState.client.getServerVersion === 'function') {
            try {
                const result = await window.appState.client.getServerVersion();
                displayResult(result, false);
                if (result) {
                    window.appDOM.serverInfoSpan.textContent = `${result.name || '未知'} v${result.version || '未知'}`;
                }
            } catch (e) {
                log(`客户端获取服务器信息失败: ${e.message}`, 'error');
                // 降级到发送自定义请求
                await sendRequestWithTransport('getServerVersion');
            }
        } else {
            // 降级到发送自定义请求
            await sendRequestWithTransport('getServerVersion');
        }
    } catch (error) {
        log(`获取服务器信息过程中发生错误: ${error.message}`, 'error');
    }
}

/**
 * 处理获取服务器能力请求
 */
async function handleGetCapabilities() {
    try {
        // 尝试使用client的getServerCapabilities方法
        if (window.appState.client && typeof window.appState.client.getServerCapabilities === 'function') {
            try {
                const result = await window.appState.client.getServerCapabilities();
                displayResult(result, false);
            } catch (e) {
                log(`客户端获取服务器能力失败: ${e.message}`, 'error');
                // 降级到发送自定义请求
                await sendRequestWithTransport('getServerCapabilities');
            }
        } else {
            // 降级到发送自定义请求
            await sendRequestWithTransport('getServerCapabilities');
        }
    } catch (error) {
        log(`获取服务器能力过程中发生错误: ${error.message}`, 'error');
    }
}

/**
 * 处理列出工具请求
 */
async function handleListTools() {
    try {
        // 尝试使用client的listTools方法
        if (window.appState.client && typeof window.appState.client.listTools === 'function') {
            try {
                const result = await window.appState.client.listTools();
                displayResult(result, false);
            } catch (e) {
                log(`客户端列出工具失败: ${e.message}`, 'error');
                // 降级到发送自定义请求
                await sendRequestWithTransport('listTools');
            }
        } else {
            // 降级到发送自定义请求
            await sendRequestWithTransport('listTools');
        }
    } catch (error) {
        log(`列出工具过程中发生错误: ${error.message}`, 'error');
    }
}

/**
 * 处理工具调用请求
 */
async function handleCallTool(params) {
    try {
        // 尝试使用client的callTool方法
        if (window.appState.client && typeof window.appState.client.callTool === 'function') {
            try {
                console.log(params)
                // 根据MCP协议规范，params应该直接包含name和arguments字段
                const result = await window.appState.client.callTool(params);
                displayResult(result, false);
            } catch (e) {
                log(`客户端工具调用失败: ${e.message}`, 'error');
                // 降级到发送自定义请求
                await sendRequestWithTransport('tools/call', params);
            }
        } else {
            console.log("xxxxx")
            // 降级到发送自定义请求
            await sendRequestWithTransport('tools/call', params);
        }
    } catch (error) {
        log(`工具调用过程中发生错误: ${error.message}`, 'error');
    }
}

/**
 * 处理complete请求
 */
async function handleComplete() {
    try {
        // 尝试使用client的complete方法
        if (window.appState.client && typeof window.appState.client.complete === 'function') {
            try {
                // 使用默认的补全参数
                const result = await window.appState.client.complete({ text: 'list' });
                displayResult(result, false);
            } catch (e) {
                log(`客户端complete请求失败: ${e.message}`, 'error');
                // 降级到发送自定义请求
                await sendRequestWithTransport('complete', { text: 'list' });
            }
        } else {
            // 降级到发送自定义请求
            await sendRequestWithTransport('complete', { text: 'list' });
        }
    } catch (error) {
        log(`complete过程中发生错误: ${error.message}`, 'error');
    }
}
